home *** CD-ROM | disk | FTP | other *** search
/ ...taking it to the Macs! / ...taking it to the Macs!.iso / Extras / ActiveX Mac SDK / ActiveX SDK / Container Common / CBindHost.cpp < prev    next >
Encoding:
Text File  |  1997-01-02  |  10.2 KB  |  610 lines  |  [TEXT/CWIE]
  1. //
  2. //    CBindHost.cpp
  3. //
  4. //    The Hook BSC for reporting Progress on IBindHost initiated 
  5. //    bindings.
  6. //
  7. //    Copyright (C) Microsoft Corporation, 1996
  8. //
  9.  
  10. #include "headers.h"
  11. #include "urlapi.h"
  12.  
  13.  
  14. #pragma mark === CBindHost Methods ===
  15.  
  16. //
  17. //  CBindHost::CBindHost
  18. //
  19. CBindHost::CBindHost(CXSite* pSite)
  20.         :       mRefCount(1), mSite(pSite), mBSCList(0)
  21. {
  22. }
  23.  
  24.  
  25. //
  26. //  CBindHost::~CBindHost
  27. //
  28. CBindHost::~CBindHost()
  29. {
  30. }
  31.  
  32. #pragma mark === CBindHost::IUnknown Interface ===
  33.  
  34. //
  35. //  CBindHost::IUnknown::QueryInterface
  36. //
  37. STDMETHODIMP CBindHost::QueryInterface(REFIID riid, LPVOID *ppvObj)
  38. {
  39.         return mSite->QueryInterface(riid, ppvObj);
  40. }
  41.  
  42. //
  43. //  CBindHost::IUnknown::AddRef
  44. //
  45. STDMETHODIMP_(ULONG) CBindHost::AddRef(void)
  46. {
  47.         ++mRefCount;
  48.         return mSite->AddRef();
  49. }
  50.  
  51.  
  52. //
  53. //  CBindHost::IUnknown::Release
  54. //
  55. STDMETHODIMP_(ULONG) CBindHost::Release(void)
  56. {
  57.         --mRefCount;
  58.         return mSite->Release();
  59. }
  60.  
  61.  
  62. #pragma mark === CBindHost::IBindHost Interface ===
  63.  
  64. //
  65. //  CBindHost::IBindHost::CreateMoniker
  66. //
  67. STDMETHODIMP CBindHost::CreateMoniker(LPOLESTR szName, IBindCtx * /* pBC */, IMoniker **ppmk, DWORD /* dwReserved */)
  68. {
  69.     HRESULT            hr = NOERROR;
  70.     IURLMoniker*    pmk;
  71.     LPOLESTR        ResolvedName;
  72.  
  73.     if ((ResolvedName = x_ExpandRelativeAnchor(szName, mSite->m_BaseURL)) == NULL)
  74.         return E_OUTOFMEMORY;
  75.  
  76. #if defined(PLUGIN_ADAPTER)
  77.  
  78.     pmk = (IURLMoniker*) new CXURLMoniker(mSite, ResolvedName);
  79.     if(!pmk)
  80.         hr = E_OUTOFMEMORY;
  81. #else
  82.  
  83.     hr = CreateURLMoniker(NULL, ResolvedName, &pmk);
  84.     CoTaskMemFree(ResolvedName);
  85. #endif
  86.     if (hr == NOERROR)
  87.     {
  88.         *ppmk = (LPMONIKER) pmk;
  89.     }
  90.     else
  91.     {
  92.         *ppmk = NULL;
  93.      }
  94.  
  95.     return hr;
  96.     
  97. }
  98.  
  99. //
  100. //  CBindHost::IBindHost::MonikerBindToStorage
  101. //
  102. STDMETHODIMP CBindHost::MonikerBindToStorage(
  103.     IMoniker *pMk,
  104.     IBindCtx *pBC,
  105.     IBindStatusCallback *pBSC,
  106.     REFIID riid,
  107.     void **ppvObj)
  108. {
  109.     return  MonikerBind(pMk, pBC, pBSC, riid, ppvObj, FALSE);
  110. }
  111.  
  112. //
  113. //  CBindHost::IBindHost::MonikerBindToObject
  114. //
  115. STDMETHODIMP CBindHost::MonikerBindToObject(
  116.     IMoniker *pMk,
  117.     IBindCtx *pBC,
  118.     IBindStatusCallback *pBSC,
  119.     REFIID riid,
  120.     void **ppvObj)
  121. {
  122.     return  MonikerBind(pMk, pBC, pBSC, riid, ppvObj, TRUE);
  123. }
  124.  
  125.  
  126. #pragma mark === CBindHost Helper Methods ===
  127.  
  128. //
  129. //  CBindHost::MonikerBind
  130. //
  131. STDMETHODIMP CBindHost::MonikerBind(
  132.     IMoniker *pMk,
  133.     IBindCtx *pBC,
  134.     IBindStatusCallback *pBSC,
  135.     REFIID riid,
  136.     void **ppvObj,
  137.     BOOL fObject)
  138. {
  139.     HRESULT hr = NOERROR;
  140.     IBindCtx *pBndCtx = pBC;
  141.     CBindHostBSC*    pBSCHook = NULL;
  142.  
  143.     if (!pMk || !ppvObj)
  144.     {
  145.         hr = E_INVALIDARG;
  146.         goto Done;
  147.     }
  148.  
  149.     if (pBndCtx == NULL)
  150.     {
  151.         hr = CreateBindCtx(0, &pBndCtx);
  152.     }
  153.     if (pBSC != NULL)
  154.     {
  155.  
  156.         hr = AddClient(pBSC, &pBSCHook);
  157.  
  158.         if (SUCCEEDED(hr))
  159.         {
  160.             hr = pBndCtx->RegisterObjectParam(REG_BSCB_HOLDER, (LPUNKNOWN) pBSCHook);
  161.             if ( SUCCEEDED(hr) )
  162.                 pBSCHook->Release();
  163.             
  164.             hr = pBndCtx->RegisterObjectParam(REG_ISL_CLIENT, (IContainerSite*) mSite);
  165.         }
  166.     }
  167.  
  168.     // if not our bind context addref it!
  169.     if (pBC != NULL && pBSCHook)
  170.     {
  171.         pBC->AddRef();
  172.  
  173.     }
  174.  
  175.     if (hr == NOERROR)
  176.     {
  177.         if (fObject)
  178.         {
  179.             hr = pMk->BindToObject(pBndCtx, NULL, riid, ppvObj);
  180.         }
  181.         else
  182.         {
  183.             hr = pMk->BindToStorage(pBndCtx, NULL, riid, ppvObj);
  184.         }
  185.     }
  186.  
  187. Done:
  188.  
  189. #if 0
  190.     if (hr != MK_S_ASYNCHRONOUS) {
  191.  
  192.         // binding either failed or completed synchronously
  193.         if (pBSCHook)
  194.         {
  195.             HRESULT hr1 = RemoveClient(pBSCHook);
  196.  
  197.             if (FAILED(hr1)) {
  198.                 hr = hr1;
  199.             }
  200.         }
  201.     }
  202. #endif
  203.  
  204.     return hr;
  205. }
  206.  
  207.  
  208. //
  209. //  CBindHost::AddClient
  210. //
  211. HRESULT
  212. CBindHost::AddClient(IBindStatusCallback *pClientBSC, CBindHostBSC **ppBSCHook)
  213. {
  214.     ASSERT(pClientBSC);
  215.     HRESULT hr = S_OK;
  216.  
  217.     *ppBSCHook = new CBindHostBSC(this, pClientBSC);
  218.  
  219.     if (!*ppBSCHook) {
  220.         hr = E_OUTOFMEMORY;
  221.         return hr;
  222.     }
  223.     if(mBSCList == NULL)
  224.         mBSCList = new LArray( sizeof(void*));
  225.     AddBSC(*ppBSCHook);
  226.  
  227.     pClientBSC->AddRef();
  228.  
  229.     return hr;
  230. }
  231.  
  232.  
  233. //
  234. //  CBindHost::RemoveClient
  235. //
  236. HRESULT
  237. CBindHost::RemoveClient(CBindHostBSC *pBSCHook)
  238. {
  239.  
  240.     if(mBSCList == NULL)
  241.         return E_FAIL;
  242.  
  243.     RemoveBSC(pBSCHook);
  244.  
  245.     pBSCHook->Release();
  246.  
  247.     return S_OK;
  248. }
  249.  
  250. //
  251. //  CBindHost::AbortBindings
  252. //
  253. HRESULT
  254. CBindHost::AbortBindings()
  255. {
  256.     // iterate through all BSCs
  257.     int iNum = GetCount() ;
  258.     for (int i=1; i <= iNum; i++)
  259.     {
  260.         CBindHostBSC *pBSCHook = GetBSC(i);
  261.  
  262.         ASSERT(pBSCHook != NULL);
  263.  
  264.         if (pBSCHook)
  265.             pBSCHook->Abort();
  266.  
  267.     }
  268.  
  269.     return S_OK;
  270. }
  271.  
  272. #pragma mark === CBindHost Utility Methods ===
  273. //
  274. //  CBindHost::AddBSC
  275. //
  276. void
  277. CBindHost::AddBSC(CBindHostBSC *Host)
  278. {
  279.     mBSCList->InsertItemsAt(1, 0x7fffffff, &Host);
  280. }
  281.  
  282. //
  283. //  CBindHost::RemoveBSC
  284. //
  285. void
  286. CBindHost::RemoveBSC(CBindHostBSC *Host)
  287. {
  288.     mBSCList->Remove(&Host);
  289. }
  290.  
  291.  
  292. //
  293. //  CBindHost::GetCount
  294. //
  295. unsigned long
  296. CBindHost::GetCount(void)
  297. {
  298.     return mBSCList ? mBSCList->GetCount() : 0;
  299. }
  300.  
  301.  
  302. //
  303. //  CBindHost::GetCount
  304. //
  305. unsigned long
  306. CBindHost::FindBSC(CBindHostBSC* Host)
  307. {
  308.     return mBSCList->FetchIndexOf(Host);
  309. }
  310.  
  311. //
  312. //  CBindHost::GetBSC
  313. //
  314. CBindHostBSC* CBindHost::GetBSC(unsigned long Index)
  315. {
  316.     CBindHostBSC*    Host = NULL;
  317.     
  318.     mBSCList->FetchItemAt(Index, &Host);
  319.     return Host;
  320. }
  321.  
  322.  
  323. #pragma mark === CBindHostBSC Methods ===
  324.  
  325. //
  326. //  CBindHostBSC::CBindHostBSC
  327. //
  328. CBindHostBSC::CBindHostBSC(CBindHost *pBindHost, IBindStatusCallback *pClientBSC):m_pBindHost(pBindHost), m_RefCount(1), m_pBinding(NULL), m_pClientBSC(pClientBSC), m_pbc(NULL)
  329. {
  330. }
  331.  
  332. //
  333. //  CBindHostBSC::~CBindHostBSC
  334. //
  335. CBindHostBSC::~CBindHostBSC()
  336. {
  337.     if (m_pBinding)
  338.         SAFERELEASE(m_pBinding);
  339.  
  340.     if (m_pClientBSC)
  341.         SAFERELEASE(m_pClientBSC);
  342.  
  343. //    if (m_pbc)
  344. //        SAFERELEASE(m_pbc);
  345. }
  346.  
  347.  
  348. //
  349. //  CBindHostBSC::Abort
  350. //
  351. HRESULT
  352. CBindHostBSC::Abort(void)
  353. {
  354.     if (m_pBinding)
  355.         m_pBinding->Abort();
  356.  
  357.     return S_OK;
  358. }
  359.  
  360. #pragma mark === CBindHostBSC IUnknown Interface ===
  361. //
  362. //  CBindHostBSC::IUnknown::QueryInterface
  363. //
  364. STDMETHODIMP
  365. CBindHostBSC::QueryInterface( REFIID riid, LPVOID *ppv )
  366. {
  367.     ASSERT(ppv != NULL);
  368.     if (ppv == NULL)
  369.             return E_INVALIDARG;
  370.  
  371.     *ppv = NULL;
  372.  
  373.     if( riid == IID_IUnknown)
  374.         *ppv = this;
  375.  
  376.     else if (riid == IID_IBindStatusCallback)
  377.         *ppv = (IBindStatusCallback *)this;
  378.  
  379.     else if (riid == IID_IServiceProvider)
  380.         *ppv = (IServiceProvider *) this;
  381.  
  382.     else
  383.         return E_NOINTERFACE;
  384.  
  385.     ((IUnknown *)*ppv)->AddRef();
  386.     return S_OK;
  387. }
  388.  
  389. //
  390. //  CBindHostBSC::IUnknown::AddRef
  391. //
  392. STDMETHODIMP_(ULONG)
  393. CBindHostBSC::AddRef()
  394. {
  395.     return(++m_RefCount);
  396. }
  397.  
  398.  
  399. //
  400. //  CBindHostBSC::IUnknown::Release
  401. //
  402. STDMETHODIMP_(ULONG)
  403. CBindHostBSC::Release()
  404. {
  405.     if(--m_RefCount==0) {
  406.         delete this;
  407.         return(0);
  408.     }
  409.  
  410.     return( m_RefCount );
  411. }
  412.  
  413.  
  414. #pragma mark === CBindHostBSC IBindStatusCallback Interface ===
  415. //
  416. //  CBindHostBSC::IBindStatusCallback::GetBindInfo
  417. //
  418. STDMETHODIMP
  419. CBindHostBSC::GetBindInfo( DWORD *grfBINDF, BINDINFO *pbindInfo)
  420. {
  421. #if 0
  422.     PMWIN   pMwin = NULL;
  423.     IUnknown *pIUnk = NULL;
  424.  
  425.     ASSERT((grfBINDF != NULL) && (pbindInfo != NULL));
  426.     if ((grfBINDF == NULL) || (pbindInfo == NULL))
  427.             return E_INVALIDARG;
  428.  
  429.     pIUnk = m_pBindHost->GetHTMLObj();
  430.     pMwin = ((HTMLObj *)(IMsoCommandTarget*)pIUnk)->GetDocMWin();
  431.     if ((pMwin) && (pMwin->flags & TW_LD_FL_REFRESH))
  432.         *grfBINDF |= BINDF_RESYNCHRONIZE;
  433.  
  434.     if ((pMwin) && (pMwin->flags & TW_LD_FL_REFRESH_ALL)) {
  435.         *grfBINDF &= ~BINDF_RESYNCHRONIZE;
  436.         *grfBINDF |= BINDF_GETNEWESTVERSION;
  437.     }
  438. #endif
  439.  
  440.     return m_pClientBSC->GetBindInfo(grfBINDF, pbindInfo);
  441. }
  442.  
  443.  
  444. //
  445. //  CBindHostBSC::IBindStatusCallback::OnStartBinding
  446. //
  447. STDMETHODIMP
  448. CBindHostBSC::OnStartBinding(DWORD grfBSCOption,IBinding *pib)
  449. {
  450.     ASSERT(pib != NULL);
  451.     if (pib == NULL)
  452.         return E_INVALIDARG;
  453.  
  454.     m_pBinding = pib;
  455.     pib->AddRef();
  456.  
  457.     return m_pClientBSC->OnStartBinding(grfBSCOption, pib);
  458. }
  459.  
  460.  
  461. //
  462. //  CBindHostBSC::IBindStatusCallback::GetPriority
  463. //
  464. STDMETHODIMP
  465. CBindHostBSC::GetPriority( LONG *pnPriority)
  466. {
  467.     return m_pClientBSC->GetPriority(pnPriority);
  468. }
  469.  
  470.  
  471. //
  472. //  CBindHostBSC::IBindStatusCallback::OnProgress
  473. //
  474. STDMETHODIMP
  475. CBindHostBSC::OnProgress
  476. (
  477.      ULONG ulProgress,
  478.      ULONG ulProgressMax,
  479.      ULONG ulStatusCode,
  480.      LPCOLESTR pwzStatusText
  481. )
  482. {
  483. #if 0
  484.     char szMsg[MAX_URL_STRING + 15];
  485.     PMWIN pmwin = ((HTMLObj *)(IMsoCommandTarget*)m_pBindHost->GetHTMLObj())->GetDocMWin();
  486.     char *lpszStatusText = NULL;
  487.  
  488.     switch (ulStatusCode)
  489.     {
  490.         case (BINDSTATUS_DOWNLOADINGDATA):
  491.  
  492.  
  493.  
  494.             Unicode2Ansi(pwzStatusText, &lpszStatusText);
  495.  
  496.             if (lpszStatusText)
  497.             {
  498.  
  499.                 GTR_formatmsg(RES_STRING_MAPCACHE1,szMsg,sizeof(szMsg),lpszStatusText);
  500.  
  501.                 if (!m_bWaitPushed) {
  502.                     WAIT_Push(pmwin, waitFullInteract, (unsigned char *)szMsg);
  503.                     m_bWaitPushed = TRUE;
  504.                 }
  505.  
  506.                 HTMLObj_SetStatusText(((IMsoCommandTarget*)m_pBindHost->GetHTMLObj())
  507.                     ,szMsg, FALSE);
  508.  
  509.                 GTR_FREE(lpszStatusText);
  510.             }
  511.  
  512.             {
  513.                 // BUGBUG DavidMay 8/1/96: If the host's progress bar had higher
  514.                 // resolution, you might want to send these more often than every
  515.                 // 5 percent, but for the current progress bar, it's more than enough.
  516.                 // Sending it every time caused enough message traffic to lock up
  517.                 // NT machines downloading large files over fast links.
  518.                 int iPercent = MulDiv(ulProgress, 100, ulProgressMax);
  519.                 if (iPercent > m_LastProgressSent + 5)
  520.                 {
  521.                     WAIT_SetRange (pmwin, 0, 100, ulProgressMax);
  522.                     WAIT_SetTherm (pmwin, ulProgress);
  523.                     m_LastProgressSent = iPercent;
  524.                 }
  525.             }
  526.  
  527.             break;
  528.  
  529.         default:
  530.             break;
  531.     }
  532. #endif
  533.  
  534.     return m_pClientBSC->OnProgress(ulProgress, ulProgressMax, ulStatusCode,
  535.         pwzStatusText);
  536. }
  537.  
  538.  
  539. //
  540. //  CBindHostBSC::IBindStatusCallback::OnDataAvailable
  541. //
  542. STDMETHODIMP
  543. CBindHostBSC::OnDataAvailable
  544. (
  545.      DWORD          grfBSCF,
  546.      DWORD          dwSize,
  547.      FORMATETC *    pFmtetc,
  548.      STGMEDIUM *    pstgmed
  549. )
  550. {
  551.  
  552.     return m_pClientBSC->OnDataAvailable(grfBSCF, dwSize, pFmtetc, pstgmed);
  553. }
  554.  
  555.  
  556. //
  557. //  CBindHostBSC::IBindStatusCallback::OnObjectAvailable
  558. //
  559. STDMETHODIMP
  560. CBindHostBSC::OnObjectAvailable ( REFIID riid, LPUNKNOWN pUnk)
  561. {
  562.     return m_pClientBSC->OnObjectAvailable(riid, pUnk);
  563. }
  564.  
  565.  
  566. //
  567. //  CBindHostBSC::IBindStatusCallback::OnLowResource
  568. //
  569. STDMETHODIMP
  570. CBindHostBSC::OnLowResource( DWORD reserved)
  571. {
  572.     return m_pClientBSC->OnLowResource(reserved);
  573. }
  574.  
  575.  
  576. //
  577. //  CBindHostBSC::IBindStatusCallback::OnStopBinding
  578. //
  579. STDMETHODIMP
  580. CBindHostBSC::OnStopBinding(HRESULT hrError, LPCOLESTR szError)
  581. {
  582.     HRESULT hr = S_OK;
  583. #if 0
  584.     PMWIN pmwin = ((HTMLObj *)(IMsoCommandTarget*)m_pBindHost->GetHTMLObj())->GetDocMWin();
  585.  
  586.     HTMLObj_SetStatusText(((IMsoCommandTarget*)m_pBindHost->GetHTMLObj()), "", FALSE);
  587.     if (m_bWaitPushed) {
  588.         WAIT_Pop(pmwin);
  589.         m_bWaitPushed = FALSE;
  590.     }
  591.  
  592.     RevokeBindStatusCallback(m_pbc, this);
  593. #endif
  594.  
  595.     SAFERELEASE(m_pBinding);
  596.  
  597.     hr = m_pClientBSC->OnStopBinding(hrError, szError);
  598.  
  599.     SAFERELEASE(m_pClientBSC);
  600.  
  601. //    if (m_pbc)
  602. //        SAFERELEASE(m_pbc);
  603.  
  604.     m_pBindHost->RemoveClient(this);
  605.  
  606.     return hr;
  607. }
  608.  
  609.  
  610.